home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / _strptime.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  14KB  |  394 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Strptime-related classes and functions.
  5.  
  6. CLASSES:
  7.     LocaleTime -- Discovers and stores locale-specific time information
  8.     TimeRE -- Creates regexes for pattern matching a string of text containing
  9.                 time information
  10.  
  11. FUNCTIONS:
  12.     _getlang -- Figure out what language is being used for the locale
  13.     strptime -- Calculates the time struct represented by the passed-in string
  14.  
  15. '''
  16. import time
  17. import locale
  18. import calendar
  19. from re import compile as re_compile
  20. from re import IGNORECASE
  21. from re import escape as re_escape
  22. from datetime import date as datetime_date
  23.  
  24. try:
  25.     from thread import allocate_lock as _thread_allocate_lock
  26. except:
  27.     from dummy_thread import allocate_lock as _thread_allocate_lock
  28.  
  29. __author__ = 'Brett Cannon'
  30. __email__ = 'brett@python.org'
  31. __all__ = [
  32.     'strptime']
  33.  
  34. def _getlang():
  35.     return locale.getlocale(locale.LC_TIME)
  36.  
  37.  
  38. class LocaleTime(object):
  39.     '''Stores and handles locale-specific information related to time.
  40.  
  41.     ATTRIBUTES:
  42.         f_weekday -- full weekday names (7-item list)
  43.         a_weekday -- abbreviated weekday names (7-item list)
  44.         f_month -- full month names (13-item list; dummy value in [0], which
  45.                     is added by code)
  46.         a_month -- abbreviated month names (13-item list, dummy value in
  47.                     [0], which is added by code)
  48.         am_pm -- AM/PM representation (2-item list)
  49.         LC_date_time -- format string for date/time representation (string)
  50.         LC_date -- format string for date representation (string)
  51.         LC_time -- format string for time representation (string)
  52.         timezone -- daylight- and non-daylight-savings timezone representation
  53.                     (2-item list of sets)
  54.         lang -- Language used by instance (2-item tuple)
  55.     '''
  56.     
  57.     def __init__(self):
  58.         '''Set all attributes.
  59.  
  60.         Order of methods called matters for dependency reasons.
  61.  
  62.         The locale language is set at the offset and then checked again before
  63.         exiting.  This is to make sure that the attributes were not set with a
  64.         mix of information from more than one locale.  This would most likely
  65.         happen when using threads where one thread calls a locale-dependent
  66.         function while another thread changes the locale while the function in
  67.         the other thread is still running.  Proper coding would call for
  68.         locks to prevent changing the locale while locale-dependent code is
  69.         running.  The check here is done in case someone does not think about
  70.         doing this.
  71.  
  72.         Only other possible issue is if someone changed the timezone and did
  73.         not call tz.tzset .  That is an issue for the programmer, though,
  74.         since changing the timezone is worthless without that call.
  75.  
  76.         '''
  77.         self.lang = _getlang()
  78.         self._LocaleTime__calc_weekday()
  79.         self._LocaleTime__calc_month()
  80.         self._LocaleTime__calc_am_pm()
  81.         self._LocaleTime__calc_timezone()
  82.         self._LocaleTime__calc_date_time()
  83.         if _getlang() != self.lang:
  84.             raise ValueError('locale changed during initialization')
  85.         
  86.  
  87.     
  88.     def __pad(self, seq, front):
  89.         seq = list(seq)
  90.         if front:
  91.             seq.insert(0, '')
  92.         else:
  93.             seq.append('')
  94.         return seq
  95.  
  96.     
  97.     def __calc_weekday(self):
  98.         a_weekday = [ calendar.day_abbr[i].lower() for i in range(7) ]
  99.         f_weekday = [ calendar.day_name[i].lower() for i in range(7) ]
  100.         self.a_weekday = a_weekday
  101.         self.f_weekday = f_weekday
  102.  
  103.     
  104.     def __calc_month(self):
  105.         a_month = [ calendar.month_abbr[i].lower() for i in range(13) ]
  106.         f_month = [ calendar.month_name[i].lower() for i in range(13) ]
  107.         self.a_month = a_month
  108.         self.f_month = f_month
  109.  
  110.     
  111.     def __calc_am_pm(self):
  112.         am_pm = []
  113.         for hour in (1, 22):
  114.             time_tuple = time.struct_time((1999, 3, 17, hour, 44, 55, 2, 76, 0))
  115.             am_pm.append(time.strftime('%p', time_tuple).lower())
  116.         
  117.         self.am_pm = am_pm
  118.  
  119.     
  120.     def __calc_date_time(self):
  121.         time_tuple = time.struct_time((1999, 3, 17, 22, 44, 55, 2, 76, 0))
  122.         date_time = [
  123.             None,
  124.             None,
  125.             None]
  126.         date_time[0] = time.strftime('%c', time_tuple).lower()
  127.         date_time[1] = time.strftime('%x', time_tuple).lower()
  128.         date_time[2] = time.strftime('%X', time_tuple).lower()
  129.         replacement_pairs = [
  130.             ('%', '%%'),
  131.             (self.f_weekday[2], '%A'),
  132.             (self.f_month[3], '%B'),
  133.             (self.a_weekday[2], '%a'),
  134.             (self.a_month[3], '%b'),
  135.             (self.am_pm[1], '%p'),
  136.             ('1999', '%Y'),
  137.             ('99', '%y'),
  138.             ('22', '%H'),
  139.             ('44', '%M'),
  140.             ('55', '%S'),
  141.             ('76', '%j'),
  142.             ('17', '%d'),
  143.             ('03', '%m'),
  144.             ('3', '%m'),
  145.             ('2', '%w'),
  146.             ('10', '%I')]
  147.         []([ (tz, '%Z') for tz_values in self.timezone for tz in tz_values ])
  148.         for offset, directive in ((0, '%c'), (1, '%x'), (2, '%X')):
  149.             current_format = date_time[offset]
  150.             for old, new in replacement_pairs:
  151.                 if old:
  152.                     current_format = current_format.replace(old, new)
  153.                     continue
  154.                 []
  155.             
  156.             time_tuple = time.struct_time((1999, 1, 3, 1, 1, 1, 6, 3, 0))
  157.             if '00' in time.strftime(directive, time_tuple):
  158.                 U_W = '%W'
  159.             else:
  160.                 U_W = '%U'
  161.             date_time[offset] = current_format.replace('11', U_W)
  162.         
  163.         self.LC_date_time = date_time[0]
  164.         self.LC_date = date_time[1]
  165.         self.LC_time = date_time[2]
  166.  
  167.     
  168.     def __calc_timezone(self):
  169.         
  170.         try:
  171.             time.tzset()
  172.         except AttributeError:
  173.             pass
  174.  
  175.         no_saving = frozenset([
  176.             'utc',
  177.             'gmt',
  178.             time.tzname[0].lower()])
  179.         if time.daylight:
  180.             has_saving = frozenset([
  181.                 time.tzname[1].lower()])
  182.         else:
  183.             has_saving = frozenset()
  184.         self.timezone = (no_saving, has_saving)
  185.  
  186.  
  187.  
  188. class TimeRE(dict):
  189.     '''Handle conversion from format directives to regexes.'''
  190.     
  191.     def __init__(self, locale_time = None):
  192.         '''Create keys/values.
  193.  
  194.         Order of execution is important for dependency reasons.
  195.  
  196.         '''
  197.         if locale_time:
  198.             self.locale_time = locale_time
  199.         else:
  200.             self.locale_time = LocaleTime()
  201.         base = super(TimeRE, self)
  202.         base.__init__({
  203.             'd': '(?P<d>3[0-1]|[1-2]\\d|0[1-9]|[1-9]| [1-9])',
  204.             'H': '(?P<H>2[0-3]|[0-1]\\d|\\d)',
  205.             'I': '(?P<I>1[0-2]|0[1-9]|[1-9])',
  206.             'j': '(?P<j>36[0-6]|3[0-5]\\d|[1-2]\\d\\d|0[1-9]\\d|00[1-9]|[1-9]\\d|0[1-9]|[1-9])',
  207.             'm': '(?P<m>1[0-2]|0[1-9]|[1-9])',
  208.             'M': '(?P<M>[0-5]\\d|\\d)',
  209.             'S': '(?P<S>6[0-1]|[0-5]\\d|\\d)',
  210.             'U': '(?P<U>5[0-3]|[0-4]\\d|\\d)',
  211.             'w': '(?P<w>[0-6])',
  212.             'y': '(?P<y>\\d\\d)',
  213.             'Y': '(?P<Y>\\d\\d\\d\\d)',
  214.             'A': self._TimeRE__seqToRE(self.locale_time.f_weekday, 'A'),
  215.             'a': self._TimeRE__seqToRE(self.locale_time.a_weekday, 'a'),
  216.             'B': self._TimeRE__seqToRE(self.locale_time.f_month[1:], 'B'),
  217.             'b': self._TimeRE__seqToRE(self.locale_time.a_month[1:], 'b'),
  218.             'p': self._TimeRE__seqToRE(self.locale_time.am_pm, 'p'),
  219.             'Z': self._TimeRE__seqToRE((lambda [outmost-iterable]: for tz_names in [outmost-iterable]:
  220. for tz in tz_names:
  221. tz)(self.locale_time.timezone), 'Z'),
  222.             '%': '%' })
  223.         base.__setitem__('W', base.__getitem__('U').replace('U', 'W'))
  224.         base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
  225.         base.__setitem__('x', self.pattern(self.locale_time.LC_date))
  226.         base.__setitem__('X', self.pattern(self.locale_time.LC_time))
  227.  
  228.     
  229.     def __seqToRE(self, to_convert, directive):
  230.         """Convert a list to a regex string for matching a directive.
  231.  
  232.         Want possible matching values to be from longest to shortest.  This
  233.         prevents the possibility of a match occuring for a value that also
  234.         a substring of a larger value that should have matched (e.g., 'abc'
  235.         matching when 'abcdef' should have been the match).
  236.  
  237.         """
  238.         to_convert = sorted(to_convert, key = len, reverse = True)
  239.         for value in to_convert:
  240.             if value != '':
  241.                 break
  242.                 continue
  243.         else:
  244.             return ''
  245.         regex = '|'.join((lambda [outmost-iterable]: for stuff in [outmost-iterable]:
  246. re_escape(stuff))(to_convert))
  247.         regex = '(?P<%s>%s' % (directive, regex)
  248.         return '%s)' % regex
  249.  
  250.     
  251.     def pattern(self, format):
  252.         '''Return regex pattern for the format string.
  253.  
  254.         Need to make sure that any characters that might be interpreted as
  255.         regex syntax are escaped.
  256.  
  257.         '''
  258.         processed_format = ''
  259.         regex_chars = re_compile('([\\\\.^$*+?\\(\\){}\\[\\]|])')
  260.         format = regex_chars.sub('\\\\\\1', format)
  261.         whitespace_replacement = re_compile('\\s+')
  262.         format = whitespace_replacement.sub('\\s*', format)
  263.         while '%' in format:
  264.             directive_index = format.index('%') + 1
  265.             processed_format = '%s%s%s' % (processed_format, format[:directive_index - 1], self[format[directive_index]])
  266.             format = format[directive_index + 1:]
  267.         return '%s%s' % (processed_format, format)
  268.  
  269.     
  270.     def compile(self, format):
  271.         '''Return a compiled re object for the format string.'''
  272.         return re_compile(self.pattern(format), IGNORECASE)
  273.  
  274.  
  275. _cache_lock = _thread_allocate_lock()
  276. _TimeRE_cache = TimeRE()
  277. _CACHE_MAX_SIZE = 5
  278. _regex_cache = { }
  279.  
  280. def strptime(data_string, format = '%a %b %d %H:%M:%S %Y'):
  281.     '''Return a time struct based on the input string and the format string.'''
  282.     global _TimeRE_cache, _regex_cache
  283.     _cache_lock.acquire()
  284.     
  285.     try:
  286.         time_re = _TimeRE_cache
  287.         locale_time = time_re.locale_time
  288.         if _getlang() != locale_time.lang:
  289.             _TimeRE_cache = TimeRE()
  290.             _regex_cache = { }
  291.         
  292.         if len(_regex_cache) > _CACHE_MAX_SIZE:
  293.             _regex_cache.clear()
  294.         
  295.         format_regex = _regex_cache.get(format)
  296.         if not format_regex:
  297.             format_regex = time_re.compile(format)
  298.             _regex_cache[format] = format_regex
  299.     finally:
  300.         _cache_lock.release()
  301.  
  302.     found = format_regex.match(data_string)
  303.     if not found:
  304.         raise ValueError('time data did not match format:  data=%s  fmt=%s' % (data_string, format))
  305.     
  306.     if len(data_string) != found.end():
  307.         raise ValueError('unconverted data remains: %s' % data_string[found.end():])
  308.     
  309.     year = 1900
  310.     month = day = 1
  311.     hour = minute = second = 0
  312.     tz = -1
  313.     week_of_year = -1
  314.     week_of_year_start = -1
  315.     weekday = julian = -1
  316.     found_dict = found.groupdict()
  317.     for group_key in found_dict.iterkeys():
  318.         if group_key == 'y':
  319.             year = int(found_dict['y'])
  320.             if year <= 68:
  321.                 year += 2000
  322.             else:
  323.                 year += 1900
  324.         year <= 68
  325.         if group_key == 'Y':
  326.             year = int(found_dict['Y'])
  327.             continue
  328.         if group_key == 'm':
  329.             month = int(found_dict['m'])
  330.             continue
  331.         if group_key == 'B':
  332.             month = locale_time.f_month.index(found_dict['B'].lower())
  333.             continue
  334.         if group_key == 'b':
  335.             month = locale_time.a_month.index(found_dict['b'].lower())
  336.             continue
  337.         if group_key == 'd':
  338.             day = int(found_dict['d'])
  339.             continue
  340.         None if group_key == 'H' else ampm in ('', locale_time.am_pm[0])
  341.         if group_key == 'M':
  342.             minute = int(found_dict['M'])
  343.             continue
  344.         if group_key == 'S':
  345.             second = int(found_dict['S'])
  346.             continue
  347.         if group_key == 'A':
  348.             weekday = locale_time.f_weekday.index(found_dict['A'].lower())
  349.             continue
  350.         None if group_key == 'a' else weekday == 0
  351.         None if group_key == 'j' else group_key == 'U'
  352.         if group_key == 'Z':
  353.             found_zone = found_dict['Z'].lower()
  354.             for value, tz_values in enumerate(locale_time.timezone):
  355.                 if found_zone in tz_values:
  356.                     if time.tzname[0] == time.tzname[1] and time.daylight and found_zone not in ('utc', 'gmt'):
  357.                         break
  358.                     else:
  359.                         tz = value
  360.                         break
  361.                 found_zone not in ('utc', 'gmt')
  362.             
  363.     
  364.     if julian == -1 and week_of_year != -1 and weekday != -1:
  365.         first_weekday = datetime_date(year, 1, 1).weekday()
  366.         preceeding_days = 7 - first_weekday
  367.         if preceeding_days == 7:
  368.             preceeding_days = 0
  369.         
  370.         if weekday == 6 and week_of_year_start == 6:
  371.             week_of_year -= 1
  372.         
  373.         if weekday == 0 and first_weekday == 0 and week_of_year_start == 6:
  374.             week_of_year += 1
  375.         
  376.         if week_of_year == 0:
  377.             julian = 1 + weekday - first_weekday
  378.         else:
  379.             days_to_week = preceeding_days + 7 * (week_of_year - 1)
  380.             julian = 1 + days_to_week + weekday
  381.     
  382.     if julian == -1:
  383.         julian = (datetime_date(year, month, day).toordinal() - datetime_date(year, 1, 1).toordinal()) + 1
  384.     else:
  385.         datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
  386.         year = datetime_result.year
  387.         month = datetime_result.month
  388.         day = datetime_result.day
  389.     if weekday == -1:
  390.         weekday = datetime_date(year, month, day).weekday()
  391.     
  392.     return time.struct_time((year, month, day, hour, minute, second, weekday, julian, tz))
  393.  
  394.